import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.util.Base64;
import java.util.Scanner;

public class DES {
    public static int ls , lc;
    public static Scanner scan = new Scanner(System.in);


    public static void main(String[] args) throws UnsupportedEncodingException {
        //知乎
        //1110 0111 1001 1111 1010 0101    1110 0100 1011 1001 1000 1110
        // a 1100001
//        String str = "slddk你好";
//        byte[] by = str.getBytes("utf-8");
//        String ss = new BigInteger(1,by).toString(2);
//        System.out.println(ss);
//        if(ss.length()%8 != 0){
//            ss = '0'+ss;
//        }




        //byte[] textByte = text.getBytes("UTF-8"); 字符串按字符集转成byte数组
        //String ak =  new String(textByte, "UTF-8"); byte数组按字符集转成字符串

        //GBK -> 2 -> base64 -> 2
//        final String text = "大";
//        //byte[]
//        final byte[] textByte = text.getBytes("GBK");
//        //String 2
//        String strB = new BigInteger(1,textByte).toString(2);
//        //base64
//        Code code = new Code();
//        String ba64 = code.toBase64(strB.toCharArray());
//        //byte[]
//        Base64.Decoder decoder = Base64.getDecoder();
//        String strD =  new String(decoder.decode(ba64), "GBK");
//        byte[] arrD = Base64.getEncoder().encode(strD.getBytes());
//        //String 2
//        String strC = new BigInteger(1,arrD).toString(2);


//        final Base64.Decoder decoder = Base64.getDecoder();
//        final Base64.Encoder encoder = Base64.getEncoder();
//        final String text = "大";
//        byte ss = 0;
//        final byte[] textByte = text.getBytes("UTF-8");
//
//        String strB = new BigInteger(1,textByte).toString(2);
//        byte[] tb = strB.getBytes("UTF-8");
//
////编码
//        final String encodedText = encoder.encodeToString(textByte);
//        String strC = new BigInteger(1,textByte).toString(2);
//        System.out.println(encodedText);
////解码
//        System.out.println(new String(decoder.decode(encodedText), "UTF-8"));




//        String ss = "1010111101000111110000101110000111011110001000000011101011110010";
//        String [] binaryArr = new String [ss.length()/8];
//        for (int i=0; i<ss.length(); i = i + 8) {
//            binaryArr[i/8] = ss.substring(i, i+8);
//            System.out.println(binaryArr[i/8]);
//        }
//
//        String s8 = String.valueOf(binaryArr);
//        System.out.println(s8);
//
//        StringBuilder strBuilder = new StringBuilder();
//        byte [] mm3 = new byte[binaryArr.length];
//        for(int i=0; i< binaryArr.length; i++) {
//
//            String m = binaryArr[i];
//            int nn4 = Integer.parseInt(m, 2);
//            byte mm = (byte)(nn4);
//            mm3[i] = mm;
//
//        }
//        System.out.print(new String(mm3, "UTF-8"));

//        char[] t = {'0','1','1','1'};
//        String ss = ""+t[0]+t[2];
//        System.out.println(ss);
//        int a = Integer.parseInt(ss,2);
//        for(int i=0; i<a; i++){
//            System.out.println(a);
//        }

//        int s = 11;
//        char[] arr32 = new char[32];
//        System.arraycopy(Integer.toString(s,2).toCharArray(), 0, arr32, 2, 4);
//
//        System.out.println(Integer.toString(s,2));


//        char a = '0';
//        char b = '1';
//        int s = a^b;
//        char[] c =  Integer.toString(s).toCharArray();
//        System.out.println(a^b);

        //测试用例：
        // str:0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
        // key:00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001
        // fin:10000101 11101000 00010011 01010100 00001111 00001010 10110100 00000101
        //String s0 = "0000000000000000000000000000000000000000000000000000000000000000";

//        String sv = "1110000100001011001011100100111111110111000000111110101101100100";//密文
//        String kv = "0101100110000111010000100011011001010001010001010110100110000111";//密钥
//        String sv = "0101010001101001100001110101001100100001010001010110000001000101";//明文
//        String kv = "0101100110000111010000100011011001010001010001010110100110000111";//密钥

//        String sv = "0000000000000000000000000000000000000000000000000000000000000000";//明文
//        String sv = "1000110010100110010011011110100111000001101100010010001110100111";//密文
//        String kv = "0000000000000000000000000000000000000000000000000000000000000000";//密钥
//        char[] s1 = sv.toCharArray();
//        char[] k1 = kv.toCharArray();

        //0000000000000000000000000000000010110100111100101011111110101000 打卡
        //0000000000000000000000000000000000000000011000010111001101100100 asd
        //1010111010010110010011101011011101110000111110011000011001010000

        Code key = new Code();
        String sd = key.encrypt("旗木卡aa","23402398");
        String reak = key.decipherin(sd,"23402398");
        System.out.println(reak);



        //2进制加解密测试
        //key.encrypt(s1,k1);
        //key.decipherin(s1,k1);


        String s0 = "asd";
        String k0 = "asd";
        //asd 2  明文bin a 01100001 s 01110011 d 01100100
        //0000000000000000000000000000000000000000 01100001 01110011 01100100  ok
        // des加密后 密文bin
        //10101111 01000111 11000010 11100001 11011110 00100000 00111010 11110010
        //密文转字符
        //字符转2进制
        //解密后 明文bin
        //1110100110101111110010101010010000000000010110110100100000101110
        //明文bin转 字符

        //转码加密测试
        //1.明文字符转bin
//        key.toArrb("asd");
        //2.明文bin加密
//        key.encrypt(s0,k0);
        //3.密文bin转密文字符
        //4.密文字符转bin
        //5.密文bin解密
        //6.明文bin转字符
//        System.out.println("加密");
//        String str = key.encrypt(s0,k0);
//        System.out.println("解密");
//        System.out.println();
//        str = key.decipherin(str,k0);
//        System.out.println(str);

        //key.toArrb("�G��� :�");
        //key.toStru8();




        //拓展置换测试
//        String str = "abcdefghijklmnopqrstuvwxyz123456";
//        key.expandReplace(str.toCharArray());
        //左移测试
        //System.out.println(key.toLf(tt,3));


    }

//1234567812345678123456781234567812345678123456781234567812345678


//    //将明文进行des加密
//    public static String desEncrypt(String plaintext,String str)
//    {
//        String ciphertext="";
//        char[][] arr = standerd(plaintext);
//        char[] key = getKey(standerd(str)[0]);
//
//        for(int i=0; i<arr.length; i++){
//            ciphertext += encrypt(arr[i], key);
//        }
//        return ciphertext;
//    }

//    //将64位字符进行des加密
//    public static String encrypt(char[] plaintext, char[] str)
//    {
//        String ciphertext="";
//        //进行ip置换
//        plaintext = ip(plaintext);
//        char[] l0 = new char[32];
//        char[] r0 = new char[32];
//        for(int i=0; i<32; i++){
//            l0[i] = plaintext[i];
//            r0[i] = plaintext[i+32];
//        }
//
//        return ciphertext;
//    }
//
//    //返回划分为64位的字符数组
//    public static char[][] standerd(String str)
//    {
//        char[][] arr = new char[str.length()/64+1][];
//        //不足64位补0
//        if(str.length()<=64){
//            for(int i=0; i<=64-str.length(); i++){
//                str += '0';
//            }
//            arr[0] = str.toCharArray();
//            return arr;
//        }
//        //多于64，分成多个数组，不够补零
//        if(str.length()>64){
//            int i=0;
//            while(str.length()>64){
//                arr[i] = str.substring(0,64).toCharArray();
//                str = str.substring(64);
//                i++;
//            }
//            arr[i] = standerd(str)[0];
//            return arr;
//        }
//        return arr;
//    }
//
//    //IP置换
//    public static char[] ip(char[] bit64)
//    {
//        char[] arr = new char[0];
//        for(int i=0; i<64; i++)
//        {
//            arr[i] = bit64[ipTable[i]-1];
//        }
//        return arr;
//    }
//
//    //逆IP置换
//    public static char[] inIp(char[] bit64)
//    {
//        char[] arr = new char[0];
//        for(int i=0; i<64; i++)
//        {
//            arr[ipTable[i]-1] = bit64[i];
//        }
//        return arr;
//    }
//
//    //返回56位密钥
//    public static char[] getFirstKey(char[] key){
//        char[] key56 = new char[56];
//        int k=0;
//        for(int i=0; i<56; i++){
//            key56[i] = key[ipTable[i]-1];
//        }
//        return key56;
//    }
//
////    //返回各轮密钥
////    public static char[] getKey(char[] keyL, char[] keyR, int round){
////
////    }
//
//    //左移操作
//    public static char[] toLf(char[] key, int digit){
//        for(int i=0; i<key.length; i++){
//            key[i] = (char) ((char)key[i]<<digit);
//        }
//        return key;
//    }
//
////    //返回48位压缩密钥
////    public static char[] getKey48(char[] key){
////
////    }
//
//
//    //
//    public static char[] toHalf(char[] bit64 , int start)
//    {
//        char[] half = new char[32];
//        for(int i=start; i<start+32; i++){
//            half[i%32] = bit64[i];
//        }
//        return half;
//    }
//








//转成ASCII码
//    public static char[][] toPart(String str) {
//        ls = str.length()/8;
//        if(str.length()%8 != 0)
//            ls++;
//        char[][] arr = new char[ls][64];
//        char[] binArr = new char[64];
//        int start=0;
//        for(int i=0; i<ls; i++) {
//            char[] temp = str.substring(start,start+8).toCharArray();
//            start += 8;
//            for(int j=0; j<8; j++) {
//                String bin = Integer.toBinaryString(temp[j]);
//                if(bin.length()!=8){
//                    while(bin.length() != 8)
//                        bin = "0" + bin;
//                }
//                for(int k=j*8; k<j*8+8; k++)
//                    binArr[k] = bin.toCharArray()[k%8];
//            }
//            for(int b=0; b<64; b++){
//                arr[i][b] = binArr[b];
//            }
//        }
//        return arr;
//    }

}